package com.yidu.hbatsams.action.AtsAttachment;

import com.yidu.hbatsams.dao.AtsSchemeAuditMapper;
import com.yidu.hbatsams.dao.UserMapper;
import com.yidu.hbatsams.domain.AtsAttachment;
import com.yidu.hbatsams.domain.AtsAttachmentEmp;
import com.yidu.hbatsams.domain.AtsSchemeAudit;
import com.yidu.hbatsams.domain.User;
import com.yidu.hbatsams.domain.vo.UserVo;
import com.yidu.hbatsams.service.AtsAttachmentEmpService;
import com.yidu.hbatsams.service.AtsAttachmentService;
import com.yidu.hbatsams.utils.FileTools;
import com.yidu.hbatsams.utils.Message;
import com.yidu.hbatsams.utils.Tools;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Controller
@RequestMapping("AtsAttachmentAction")
public class AtsAttachmentAction {
    @Resource
    AtsSchemeAuditMapper atsSchemeAuditMapper;
    @Resource
    FileTools fileTools;
    @Resource
    AtsAttachmentService atsAttachmentService;
    @Resource
    AtsAttachmentEmpService atsAttachmentEmpService;
    /**
     * 模糊查询插件分页
     * @param atsAttachment
     * @param pageNum
     * @param pageSize
     * @return
     */
    @RequestMapping("select")
    @ResponseBody
    public Map<String,Object> select(AtsAttachment atsAttachment, @RequestParam("page") Integer pageNum,@RequestParam("limit") Integer pageSize,HttpSession session){
        //获取作用域中的用户
        UserVo user=(UserVo)session.getAttribute("user");
        //判定模型中的懒可属性不为空时
        if(atsAttachment.getAttachIdLike()!=null){
            //提取当前作用域的属性给模型的懒可属性赋值
            atsAttachment.setRemark(user.getUserName());
            //调用修改方法将模型放入
            atsAttachmentService.updateRemark(atsAttachment);
        }
        //创建一个存储键值对象
        Map<String,Object> map=new HashMap<String,Object>();
        //创建一个以当前模型作为模板的泛型集合,集合来源调用方法
        List<AtsAttachment> list=atsAttachmentService.select(atsAttachment,pageNum,pageSize);
        //存入键值对
        map.put("code", 0);
        //存入键值对
        map.put("msg", "");
        //存入键值对
        map.put("count", atsAttachmentService.selectCount(atsAttachment));
        //存入键值对
        map.put("data", list);
        //返回存入键值对的对象
        return map;
    }

    /**
     * 逻辑删除
     * @param atsAttachment
     * @return
     */
    @RequestMapping("updateByPrimaryKeySelective")
    @ResponseBody
    public Message updateByPrimaryKeySelective(AtsAttachment atsAttachment){
        //创建一个状态类
        Message mg=new Message();
        //定义一个变量值为调用的方法
        int rows=atsAttachmentService.updateByPrimaryKeySelective(atsAttachment);
        //如果变量大于零则说明方法调用成功
        if(rows>0){
            //对象的属性赋值
            mg.setNum(1);
            //对象的属性赋值
            mg.setMsg("删除成功");
            //否则变量的其他情况
        }else{
            //对象的属性赋值
            mg.setNum(0);
            //对象的属性赋值
            mg.setMsg("删除失败");
        }
        //返回已赋值的对象
        return mg;
    }

    /**
     * Id查询
     * @param attachId
     * @return
     */
    @RequestMapping("selectByPrimaryKey")
    @ResponseBody
    public AtsAttachment selectByPrimaryKey(Integer attachId){
        //调用根据艾低查询创建一个对象
        AtsAttachment atsAttachment=atsAttachmentService.selectByPrimaryKey(attachId);
        //返回对象
        return atsAttachment;
    }
    @RequestMapping("addUpdate")
    @ResponseBody
    public Message addUpdate(@RequestParam(value = "imgText1", required = false) MultipartFile imgText1,@RequestParam(value = "imgText2", required = false) MultipartFile imgText2,@RequestParam(value = "imgText3", required = false) MultipartFile imgText3, AtsAttachment atsAttachment, String site2, String site3, String site1,String[] userId,String[] nameId,HttpSession session,String auditresult) throws IOException {
        //定义特定值的变量
        int rows=0;
        //定义特定值的变量
        int atsId=0;
        //创建一个状态类
        Message mg=new Message();
        //如果模型艾低不为空的话
        if(atsAttachment.getAttachId()==null){
            //定义变量改为10
            atsId=10;
        }
        //调用文件上传工具类的方法，定义一个字符串进行储存
        String f1=fileTools.saveFile("ffgn",imgText1);
        //调用文件上传工具类的方法，定义一个字符串进行储存
        String f2=fileTools.saveFile("ffgn",imgText2);
        //调用文件上传工具类的方法，定义一个字符串进行储存
        String f3=fileTools.saveFile("ffgn",imgText3);
        //艾低不为空执行修改
        if(atsAttachment.getAttachId()!=null){
            //接收前台的复选框值不为空的话
            if(userId!=null){
                //定义一个空的字符串
                String str="";
                //根据复选框值作为for循环条件
                for(int i=0;i<userId.length;i++){
                    //每次循环用定义的字符串接收
                    str+=userId[i]+",";
                }
                //创建关联用户的模型类
                AtsAttachmentEmp atsAttachmentEmps=new AtsAttachmentEmp();
                //模型艾低赋值前对象的艾低
                atsAttachmentEmps.setAttachId(atsAttachment.getAttachId());
                //调用方法创建以原模型为基础的泛集合
                List<AtsAttachmentEmp> list=atsAttachmentEmpService.atsfindId(atsAttachmentEmps);
                //创建一个无字段的字符串
                String moon="";
                //以当前的模型集合作为循环条件
                for (AtsAttachmentEmp atsAttachmentEmp : list) {
                    //如何条件对象中有属性与字符串对应
                    if(str.indexOf(atsAttachmentEmp.getUserId()+"."+atsAttachmentEmp.getUserName())!=-1) {
                        //则属性状态改为有效
                        atsAttachmentEmp.setIsva(1);
                        //调用修改方法
                        atsAttachmentEmpService.updateByPrimaryKeySelective(atsAttachmentEmp);
                    }else{
                        //否则属性状态改为无效
                        atsAttachmentEmp.setIsva(0);
                        //调用修改方法
                        atsAttachmentEmpService.updateByPrimaryKeySelective(atsAttachmentEmp);
                    }
                    //字符串再叠加
                    moon+=atsAttachmentEmp.getUserId()+"."+atsAttachmentEmp.getUserName()+",";
                }
                //根据复选框值作为for循环条件
                for (int j=0;j<userId.length;j++){
                    //如果有属性与叠加字符串重合
                    if(moon.indexOf(userId[j])==-1){
                        //创建关联用户的模型类
                        AtsAttachmentEmp atsAttachmentEmpl=new AtsAttachmentEmp();
                        //当前模型艾低赋值
                        atsAttachmentEmpl.setAttachId(atsAttachment.getAttachId());
                        //属性赋值为不可查看
                        atsAttachmentEmpl.setIsLook("0");
                        //属性赋值为有效
                        atsAttachmentEmpl.setIsva(1);
                        //创建当前时间
                        Date date=new Date();
                        //对象属性赋值为当前时间
                        atsAttachmentEmpl.setCreatTime(date);
                        //根据点分割前台复选框值定义一个数组接收
                        String[] nameIds=userId[j].split("\\.");
                        //当前模型艾低赋值为数组第一个
                        atsAttachmentEmpl.setUserId(nameIds[0]);
                        //当前模型用户名字赋值为数组第二个
                        atsAttachmentEmpl.setUserName(nameIds[1]);
                        //以当前模型作为条件调用增加方法
                        atsAttachmentEmpService.insert(atsAttachmentEmpl);
                    }
                }
            }
            //如果定义接收文件的字符串为空
            if(f1==null){
                //则模型属性赋值为方法中定义的文件名
                atsAttachment.setFile1(site1);
            }else{
                //不为空的话赋值当前接收文件的字符串
                atsAttachment.setFile1(f1);
            }
            //如果定义接收文件的字符串为空
            if(f2==null){
                //则模型属性赋值为方法中定义的文件名
                atsAttachment.setFile2(site2);
            }else{
                //不为空的话赋值当前接收文件的字符串
                atsAttachment.setFile2(f2);
            }
            //如果定义接收文件的字符串为空
            if(f3==null){
                //则模型属性赋值为方法中定义的文件名
                atsAttachment.setFile3(site3);
            }else{
                //不为空的话赋值当前接收文件的字符串
                atsAttachment.setFile3(f3);
            }
            //如果文件类型为通知公告
            if(atsAttachment.getAttachType().equals("10")){
                //则将该文件状态改为发布
                atsAttachment.setAuditState(10);
                //将属性改为不需要审核
                atsAttachment.setIsAudit(1);
                //如果是其他文件
            }else{
                //将文件状态改为待审核
                atsAttachment.setAuditState(20);
                //将属性改为需要审核
                atsAttachment.setIsAudit(2);
            }
            //属性备注改为修改
            atsAttachment.setRemark("修改");
            //调用修改方法赋值给初始定义的变量
            rows=atsAttachmentService.updateByPrimaryKeySelective(atsAttachment);
        }else{//执行增加
            //根据作用域拿到用户模型信息
            UserVo user = (UserVo) session.getAttribute("user");
            //模型属性赋值为当前时间
            atsAttachment.setAttachTime(Tools.getCurDate());
            //属性状态改为待审核
            atsAttachment.setAuditState(20);
            //属性备注改为新增
            atsAttachment.setRemark("新增");
            //附件一赋值
            atsAttachment.setFile1(f1);
            //附件二赋值
            atsAttachment.setFile2(f2);
            //附件三赋值
            atsAttachment.setFile3(f3);
            //属性赋值为当前作用域取的用户名称
            atsAttachment.setAttachPublisher(user.getUserName());
            //定义一个无字段字符串
            String atsAttaId = "";
            //条件循坏九次
            for (int j = 0; j < 9; j++) {
                //字符串叠加赋值
                atsAttaId += Tools.getRandomNumber(10);
            }
            //属性艾低抢转
            atsAttachment.setAttachId(Integer.valueOf(atsAttaId));
            //属性赋值为有效
            atsAttachment.setIsva(0);
            //如果文件类型为通知公告
            if (atsAttachment.getAttachType().equals("10")) {
                //获取当前时间
                Date date1 = new Date();
                //属性赋值当前时间
                atsAttachment.setCreatTime(date1);
                //属性审核状态为发布
                atsAttachment.setAuditState(10);
                //属性设置为不需要审核
                atsAttachment.setIsAudit(1);
                //属性赋值为有效
                atsAttachment.setIsva(1);
            } else {
                //属性赋值为需要审核
                atsAttachment.setIsAudit(2);
            }
            //调用增加方法赋值给初始定义变量
            rows = atsAttachmentService.insert(atsAttachment);
            //如果前台复选框值不为空的话
            if (userId != null) {
                //创建关联用户的模型
                AtsAttachmentEmp atsAttachmentEmp = new AtsAttachmentEmp();
                //模型属性艾低赋值
                atsAttachmentEmp.setAttachId(atsAttachment.getAttachId());
                //属性赋值为有效
                atsAttachmentEmp.setIsva(1);
                //创建当前时间
                Date date = new Date();
                //模型属性赋值当前时间
                atsAttachmentEmp.setCreatTime(date);
                //以前台复选框的长度作为循环条件
                for (int i = 0; i < userId.length; i++) {
                    //以点分割复选框值用以创建的数组接收
                    nameId = userId[i].split("\\.");
                    //属性艾低赋值为数组第一个
                    atsAttachmentEmp.setUserId(nameId[0]);
                    //属性用户名字赋值为数组第二个
                    atsAttachmentEmp.setUserName(nameId[1]);
                    //以当前模型为条件调用增加方法
                    atsAttachmentEmpService.insert(atsAttachmentEmp);
                }
            }
        }
        //如果定值大于零
        if(rows>0){
            //属性状态改为成功
            mg.setNum(1);
            //如果文件类型为通知公告并且是发布的状态
            if(atsId==10&&atsAttachment.getAttachType().equals("10")){
                //属性状态改为未进行任何操作
                mg.setNum(10);
            }
            //属性消息弹出改为操作成功
            mg.setMsg("操作成功");
        }else{
            //属性状态改为失败
            mg.setNum(0);
            //属性消息弹出改为操作成功
            mg.setMsg("操作失败");
        }
        //返回对象
        return mg;
    }
    @Resource
    private UserMapper userMapper;

    @RequestMapping("userAll")
    @ResponseBody
    public List<User> userAll(){
        return userMapper.findAll(null);
    }

    public void Record(String auExp,HttpSession session,AtsAttachment atsAttachment,String auditState){
        //创建审核类型模型对象
        AtsSchemeAudit atsSchemeAudit=new AtsSchemeAudit();
        //取出作用域中的用户并创建用户接收
        UserVo user=(UserVo) session.getAttribute("user");
        //创建当前时间
        Date date=new Date();
        //属性赋值当前时间
        atsSchemeAudit.setAuTime(Tools.getCurDateTime());
        //属性赋值审核内容
        atsSchemeAudit.setAuExp(auExp);
        //属性外键赋值
        atsSchemeAudit.setSaId(String.valueOf(atsAttachment.getAttachId()));
        //属性文件类型赋值
        atsSchemeAudit.setSaName(atsAttachment.getAttachType());
        //属性状态赋值
        atsSchemeAudit.setAuditState(auditState);
        //属性创建人赋值
        atsSchemeAudit.setCreater(user.getUserName());
        //属性当前创建时间赋值
        atsSchemeAudit.setCreatTime(date);
        //属性赋值为有效
        atsSchemeAudit.setIsva(1);
        //属性备注赋值审核
        atsSchemeAudit.setRemark("审核");
        //以当前模型为条件调用增加方法
        atsSchemeAuditMapper.insert(atsSchemeAudit);
    }
    @RequestMapping("audit")
    @ResponseBody
    public Message audit(AtsAttachment atsAttachment,HttpSession session,String auExp){
        //创建状态类
        Message mg=new Message();
        //属性赋值为有效
        atsAttachment.setIsva(1);
        //属性发布时间赋值为工具类提取当前时间
        atsAttachment.setAttachValidTime(Tools.getCurDate());
        //属性状态为发布
        atsAttachment.setAuditState(10);
        //如果属性备注为修改
        if(!atsAttachment.getRemark().equals("修改")) {
            //创建一个关联用户表
            AtsAttachmentEmp atsAttachmentEmp = new AtsAttachmentEmp();
            //当前对象艾低赋值
            atsAttachmentEmp.setAttachId(atsAttachment.getAttachId());
            //属性赋值为有效
            atsAttachmentEmp.setIsva(1);
            //以当前对象作为条件调用修改方法
            atsAttachmentEmpService.updateIsva(atsAttachmentEmp);
        }
        //以对象作为条件调用修改方法定义变量接收
        int rows=atsAttachmentService.updateByPrimaryKeySelective(atsAttachment);
        //如果变量值大于零
        if(rows>0){
            //传入参数执行方法
            Record(auExp,session,atsAttachment,"20");
            //属性赋值为数字成功
            mg.setNum(1);
            //属性付志伟文字成功
            mg.setMsg("操作成功");
        }else{
            //属性赋值为数字失败
            mg.setNum(0);
            //属性赋值为文字失败
            mg.setMsg("操作失败");
        }
        //返回对象
        return mg;
    }
    @RequestMapping("selectEmp")
    @ResponseBody
    public List<AtsAttachment> selectEmp(HttpSession session){
        return atsAttachmentService.selectEmp(session);
    }
    @RequestMapping("auditResult")
    @ResponseBody
    public Message auditResult(AtsAttachment atsAttachment,String[] userId,String[] nameId,HttpSession session){
        //创建状态类
        Message mg=new Message();
        //取出作用域中的用户并创建用户接收
        UserVo user=(UserVo)session.getAttribute("user");
        //属性赋值当前时间
        atsAttachment.setAttachTime(Tools.getCurDate());
        //属性赋值文件标题
        atsAttachment.setAttachName("审核意见");
        //属性赋值文件类型为通知公告
        atsAttachment.setAttachType("10");
        //属性赋值发布人为当前登录人姓名
        atsAttachment.setAttachPublisher(user.getUserName());
        //定义无字段字符串
        String atsAttaId="";
        //以循环九次作为条件
        for(int j=0;j<9;j++){
            //每次叠加字符
            atsAttaId+=Tools.getRandomNumber(10);
        }
        //属性艾低数字强转赋值
        atsAttachment.setAttachId(Integer.valueOf(atsAttaId));
        //属性状态改为发布
        atsAttachment.setAuditState(10);
        //属性赋值为不审核状态
        atsAttachment.setIsAudit(1);
        //属性赋值为有效
        atsAttachment.setIsva(1);
        //以对象为条件调用增加方法定义变量接收
        int rows= atsAttachmentService.insert(atsAttachment);
        //如果前台复选框值不为空
        if(userId!=null){
            //创建关联用户的对象
            AtsAttachmentEmp atsAttachmentEmps=new AtsAttachmentEmp();
            //属性艾低赋值为另对象的艾低
            atsAttachmentEmps.setAttachId(atsAttachment.getAttachId());
            //属性赋值为未查看
            atsAttachmentEmps.setIsLook("0");
            //属性赋值为有效
            atsAttachmentEmps.setIsva(1);
            //创建当前时间
            Date date=new Date();
            //属性赋值创建时间
            atsAttachmentEmps.setCreatTime(date);
            //根据前台复选框值长度作为循环条件
            for(int i=0;i<userId.length;i++){
                //用点分割复选框用以定义数组接收
                nameId=userId[i].split("\\.");
                //属性用户ID赋值数组第一个
                atsAttachmentEmps.setUserId(nameId[0]);
                //属性用户姓名赋值数组第二个
                atsAttachmentEmps.setUserName(nameId[1]);
                //以模型为条件调用增加方法
                atsAttachmentEmpService.insert(atsAttachmentEmps);
            }
        }
        //如果定义变量大于零
        if(rows>0){
            //属性状态赋值数字成功
            mg.setNum(1);
            //属性状态赋值文字成功
            mg.setMsg("操作成功");
        }else{
            //属性状态赋值数字失败
            mg.setNum(0);
            //属性状态赋值文字失败
            mg.setMsg("操作失败");
        }
        //返回对象
        return mg;
    }
    @RequestMapping("updateState")
    @ResponseBody
    public Message updateState(String auExp,AtsAttachment atsAttachment,HttpSession session){
        //创建一个状态类
        Message mg=new Message();
        //以调用ID查询方法创建模型
        AtsAttachment atsAttachment1=atsAttachmentService.selectByPrimaryKey(atsAttachment.getAttachId());
        //属性赋值审核状态
        atsAttachment1.setAuditState(atsAttachment.getAuditState());
        //以对象作为条件调用修改方法并定义变量接收
        int rows=atsAttachmentService.updateByPrimaryKeySelective(atsAttachment1);
        //如果变量大于零
        if(rows>0){
            //传入参数执行方法
            Record(auExp,session,atsAttachment,"21");
            //属性赋值数字成功标识
            mg.setNum(1);
            //属性赋值文字成功标识
            mg.setMsg("操作成功");
        }else{
            //属性赋值数字失败标识
            mg.setNum(0);
            //属性赋值数字失败标识
            mg.setMsg("操作失败");
        }
        //返回对象
        return mg;
    }
}